<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
<title>DSCompiler (Apache Commons Math 3.3 API)</title>
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
</head>
<body>
<script type="text/javascript"><!--
    if (location.href.indexOf('is-external=true') == -1) {
        parent.document.title="DSCompiler (Apache Commons Math 3.3 API)";
    }
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar_top">
<!--   -->
</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/DSCompiler.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage"><em><script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script></em></div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DerivativeStructure.html" title="class in org.apache.commons.math3.analysis.differentiation"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/FiniteDifferencesDifferentiator.html" title="class in org.apache.commons.math3.analysis.differentiation"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../../index.html?org/apache/commons/math3/analysis/differentiation/DSCompiler.html" target="_top">Frames</a></li>
<li><a href="DSCompiler.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.apache.commons.math3.analysis.differentiation</div>
<h2 title="Class DSCompiler" class="title">Class DSCompiler</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.apache.commons.math3.analysis.differentiation.DSCompiler</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public class <span class="strong">DSCompiler</span>
extends <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></pre>
<div class="block">Class holding "compiled" computation rules for derivative structures.
 <p>This class implements the computation rules described in Dan Kalman's paper <a
 href="http://www1.american.edu/cas/mathstat/People/kalman/pdffiles/mmgautodiff.pdf">Doubly
 Recursive Multivariate Automatic Differentiation</a>, Mathematics Magazine, vol. 75,
 no. 3, June 2002. However, in order to avoid performances bottlenecks, the recursive
 rules are "compiled" once in an unfold form. This class does this recursion unrolling
 and stores the computation rules as simple loops with pre-computed indirection arrays.</p>
 <p>
 This class maps all derivative computation into single dimension arrays that hold the
 value and partial derivatives. The class does not hold these arrays, which remains under
 the responsibility of the caller. For each combination of number of free parameters and
 derivation order, only one compiler is necessary, and this compiler will be used to
 perform computations on all arrays provided to it, which can represent hundreds or
 thousands of different parameters kept together with all theur partial derivatives.
 </p>
 <p>
 The arrays on which compilers operate contain only the partial derivatives together
 with the 0<sup>th</sup> derivative, i.e. the value. The partial derivatives are stored in
 a compiler-specific order, which can be retrieved using methods <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getPartialDerivativeIndex(int...)"><code>getPartialDerivativeIndex</code></a> and <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getPartialDerivativeOrders(int)"><code>getPartialDerivativeOrders(int)</code></a>. The value is guaranteed to be stored as the first element
 (i.e. the <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getPartialDerivativeIndex(int...)"><code>getPartialDerivativeIndex</code></a> method returns
 0 when called with 0 for all derivation orders and <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getPartialDerivativeOrders(int)"><code>getPartialDerivativeOrders</code></a> returns an array filled with 0 when called with 0 as the index).
 </p>
 <p>
 Note that the ordering changes with number of parameters and derivation order. For example
 given 2 parameters x and y, df/dy is stored at index 2 when derivation order is set to 1 (in
 this case the array has three elements: f, df/dx and df/dy). If derivation order is set to
 2, then df/dy will be stored at index 3 (in this case the array has six elements: f, df/dx,
 df/dxdx, df/dy, df/dxdy and df/dydy).
 </p>
 <p>
 Given this structure, users can perform some simple operations like adding, subtracting
 or multiplying constants and negating the elements by themselves, knowing if they want to
 mutate their array or create a new array. These simple operations are not provided by
 the compiler. The compiler provides only the more complex operations between several arrays.
 </p>
 <p>This class is mainly used as the engine for scalar variable <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DerivativeStructure.html" title="class in org.apache.commons.math3.analysis.differentiation"><code>DerivativeStructure</code></a>.
 It can also be used directly to hold several variables in arrays for more complex data
 structures. User can for example store a vector of n variables depending on three x, y
 and z free parameters in one array as follows:
 <pre>
   // parameter 0 is x, parameter 1 is y, parameter 2 is z
   int parameters = 3;
   DSCompiler compiler = DSCompiler.getCompiler(parameters, order);
   int size = compiler.getSize();

   // pack all elements in a single array
   double[] array = new double[n * size];
   for (int i = 0; i < n; ++i) {

     // we know value is guaranteed to be the first element
     array[i * size] = v[i];

     // we don't know where first derivatives are stored, so we ask the compiler
     array[i * size + compiler.getPartialDerivativeIndex(1, 0, 0) = dvOnDx[i][0];
     array[i * size + compiler.getPartialDerivativeIndex(0, 1, 0) = dvOnDy[i][0];
     array[i * size + compiler.getPartialDerivativeIndex(0, 0, 1) = dvOnDz[i][0];

     // we let all higher order derivatives set to 0

   }
 </pre>
 Then in another function, user can perform some operations on all elements stored
 in the single array, such as a simple product of all variables:
 <pre>
   // compute the product of all elements
   double[] product = new double[size];
   prod[0] = 1.0;
   for (int i = 0; i < n; ++i) {
     double[] tmp = product.clone();
     compiler.multiply(tmp, 0, array, i * size, product, 0);
   }

   // value
   double p = product[0];

   // first derivatives
   double dPdX = product[compiler.getPartialDerivativeIndex(1, 0, 0)];
   double dPdY = product[compiler.getPartialDerivativeIndex(0, 1, 0)];
   double dPdZ = product[compiler.getPartialDerivativeIndex(0, 0, 1)];

   // cross derivatives (assuming order was at least 2)
   double dPdXdX = product[compiler.getPartialDerivativeIndex(2, 0, 0)];
   double dPdXdY = product[compiler.getPartialDerivativeIndex(1, 1, 0)];
   double dPdXdZ = product[compiler.getPartialDerivativeIndex(1, 0, 1)];
   double dPdYdY = product[compiler.getPartialDerivativeIndex(0, 2, 0)];
   double dPdYdZ = product[compiler.getPartialDerivativeIndex(0, 1, 1)];
   double dPdZdZ = product[compiler.getPartialDerivativeIndex(0, 0, 2)];
 </p></div>
<dl><dt><span class="strong">Since:</span></dt>
  <dd>3.1</dd>
<dt><span class="strong">Version:</span></dt>
  <dd>$Id: DSCompiler.java 1517788 2013-08-27 11:15:18Z luc $</dd>
<dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DerivativeStructure.html" title="class in org.apache.commons.math3.analysis.differentiation"><code>DerivativeStructure</code></a></dd></dl>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method_summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#acos(double[], int, double[], int)">acos</a></strong>(double[]&nbsp;operand,
    int&nbsp;operandOffset,
    double[]&nbsp;result,
    int&nbsp;resultOffset)</code>
<div class="block">Compute arc cosine of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#acosh(double[], int, double[], int)">acosh</a></strong>(double[]&nbsp;operand,
     int&nbsp;operandOffset,
     double[]&nbsp;result,
     int&nbsp;resultOffset)</code>
<div class="block">Compute inverse hyperbolic cosine of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#add(double[], int, double[], int, double[], int)">add</a></strong>(double[]&nbsp;lhs,
   int&nbsp;lhsOffset,
   double[]&nbsp;rhs,
   int&nbsp;rhsOffset,
   double[]&nbsp;result,
   int&nbsp;resultOffset)</code>
<div class="block">Perform addition of two derivative structures.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#asin(double[], int, double[], int)">asin</a></strong>(double[]&nbsp;operand,
    int&nbsp;operandOffset,
    double[]&nbsp;result,
    int&nbsp;resultOffset)</code>
<div class="block">Compute arc sine of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#asinh(double[], int, double[], int)">asinh</a></strong>(double[]&nbsp;operand,
     int&nbsp;operandOffset,
     double[]&nbsp;result,
     int&nbsp;resultOffset)</code>
<div class="block">Compute inverse hyperbolic sine of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#atan(double[], int, double[], int)">atan</a></strong>(double[]&nbsp;operand,
    int&nbsp;operandOffset,
    double[]&nbsp;result,
    int&nbsp;resultOffset)</code>
<div class="block">Compute arc tangent of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#atan2(double[], int, double[], int, double[], int)">atan2</a></strong>(double[]&nbsp;y,
     int&nbsp;yOffset,
     double[]&nbsp;x,
     int&nbsp;xOffset,
     double[]&nbsp;result,
     int&nbsp;resultOffset)</code>
<div class="block">Compute two arguments arc tangent of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#atanh(double[], int, double[], int)">atanh</a></strong>(double[]&nbsp;operand,
     int&nbsp;operandOffset,
     double[]&nbsp;result,
     int&nbsp;resultOffset)</code>
<div class="block">Compute inverse hyperbolic tangent of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#checkCompatibility(org.apache.commons.math3.analysis.differentiation.DSCompiler)">checkCompatibility</a></strong>(<a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html" title="class in org.apache.commons.math3.analysis.differentiation">DSCompiler</a>&nbsp;compiler)</code>
<div class="block">Check rules set compatibility.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#compose(double[], int, double[], double[], int)">compose</a></strong>(double[]&nbsp;operand,
       int&nbsp;operandOffset,
       double[]&nbsp;f,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</code>
<div class="block">Compute composition of a derivative structure by a function.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#cos(double[], int, double[], int)">cos</a></strong>(double[]&nbsp;operand,
   int&nbsp;operandOffset,
   double[]&nbsp;result,
   int&nbsp;resultOffset)</code>
<div class="block">Compute cosine of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#cosh(double[], int, double[], int)">cosh</a></strong>(double[]&nbsp;operand,
    int&nbsp;operandOffset,
    double[]&nbsp;result,
    int&nbsp;resultOffset)</code>
<div class="block">Compute hyperbolic cosine of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#divide(double[], int, double[], int, double[], int)">divide</a></strong>(double[]&nbsp;lhs,
      int&nbsp;lhsOffset,
      double[]&nbsp;rhs,
      int&nbsp;rhsOffset,
      double[]&nbsp;result,
      int&nbsp;resultOffset)</code>
<div class="block">Perform division of two derivative structures.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#exp(double[], int, double[], int)">exp</a></strong>(double[]&nbsp;operand,
   int&nbsp;operandOffset,
   double[]&nbsp;result,
   int&nbsp;resultOffset)</code>
<div class="block">Compute exponential of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#expm1(double[], int, double[], int)">expm1</a></strong>(double[]&nbsp;operand,
     int&nbsp;operandOffset,
     double[]&nbsp;result,
     int&nbsp;resultOffset)</code>
<div class="block">Compute exp(x) - 1 of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html" title="class in org.apache.commons.math3.analysis.differentiation">DSCompiler</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getCompiler(int, int)">getCompiler</a></strong>(int&nbsp;parameters,
           int&nbsp;order)</code>
<div class="block">Get the compiler for number of free parameters and order.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>int</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getFreeParameters()">getFreeParameters</a></strong>()</code>
<div class="block">Get the number of free parameters.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>int</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getOrder()">getOrder</a></strong>()</code>
<div class="block">Get the derivation order.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>int</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getPartialDerivativeIndex(int...)">getPartialDerivativeIndex</a></strong>(int...&nbsp;orders)</code>
<div class="block">Get the index of a partial derivative in the array.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>int[]</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getPartialDerivativeOrders(int)">getPartialDerivativeOrders</a></strong>(int&nbsp;index)</code>
<div class="block">Get the derivation orders for a specific index in the array.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>int</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getSize()">getSize</a></strong>()</code>
<div class="block">Get the array size required for holding partial derivatives data.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#linearCombination(double, double[], int, double, double[], int, double[], int)">linearCombination</a></strong>(double&nbsp;a1,
                 double[]&nbsp;c1,
                 int&nbsp;offset1,
                 double&nbsp;a2,
                 double[]&nbsp;c2,
                 int&nbsp;offset2,
                 double[]&nbsp;result,
                 int&nbsp;resultOffset)</code>
<div class="block">Compute linear combination.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#linearCombination(double, double[], int, double, double[], int, double, double[], int, double[], int)">linearCombination</a></strong>(double&nbsp;a1,
                 double[]&nbsp;c1,
                 int&nbsp;offset1,
                 double&nbsp;a2,
                 double[]&nbsp;c2,
                 int&nbsp;offset2,
                 double&nbsp;a3,
                 double[]&nbsp;c3,
                 int&nbsp;offset3,
                 double[]&nbsp;result,
                 int&nbsp;resultOffset)</code>
<div class="block">Compute linear combination.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#linearCombination(double, double[], int, double, double[], int, double, double[], int, double, double[], int, double[], int)">linearCombination</a></strong>(double&nbsp;a1,
                 double[]&nbsp;c1,
                 int&nbsp;offset1,
                 double&nbsp;a2,
                 double[]&nbsp;c2,
                 int&nbsp;offset2,
                 double&nbsp;a3,
                 double[]&nbsp;c3,
                 int&nbsp;offset3,
                 double&nbsp;a4,
                 double[]&nbsp;c4,
                 int&nbsp;offset4,
                 double[]&nbsp;result,
                 int&nbsp;resultOffset)</code>
<div class="block">Compute linear combination.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#log(double[], int, double[], int)">log</a></strong>(double[]&nbsp;operand,
   int&nbsp;operandOffset,
   double[]&nbsp;result,
   int&nbsp;resultOffset)</code>
<div class="block">Compute natural logarithm of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#log10(double[], int, double[], int)">log10</a></strong>(double[]&nbsp;operand,
     int&nbsp;operandOffset,
     double[]&nbsp;result,
     int&nbsp;resultOffset)</code>
<div class="block">Computes base 10 logarithm of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#log1p(double[], int, double[], int)">log1p</a></strong>(double[]&nbsp;operand,
     int&nbsp;operandOffset,
     double[]&nbsp;result,
     int&nbsp;resultOffset)</code>
<div class="block">Computes shifted logarithm of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#multiply(double[], int, double[], int, double[], int)">multiply</a></strong>(double[]&nbsp;lhs,
        int&nbsp;lhsOffset,
        double[]&nbsp;rhs,
        int&nbsp;rhsOffset,
        double[]&nbsp;result,
        int&nbsp;resultOffset)</code>
<div class="block">Perform multiplication of two derivative structures.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#pow(double[], int, double[], int, double[], int)">pow</a></strong>(double[]&nbsp;x,
   int&nbsp;xOffset,
   double[]&nbsp;y,
   int&nbsp;yOffset,
   double[]&nbsp;result,
   int&nbsp;resultOffset)</code>
<div class="block">Compute power of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#pow(double[], int, double, double[], int)">pow</a></strong>(double[]&nbsp;operand,
   int&nbsp;operandOffset,
   double&nbsp;p,
   double[]&nbsp;result,
   int&nbsp;resultOffset)</code>
<div class="block">Compute power of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#pow(double[], int, int, double[], int)">pow</a></strong>(double[]&nbsp;operand,
   int&nbsp;operandOffset,
   int&nbsp;n,
   double[]&nbsp;result,
   int&nbsp;resultOffset)</code>
<div class="block">Compute integer power of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#pow(double, double[], int, double[], int)">pow</a></strong>(double&nbsp;a,
   double[]&nbsp;operand,
   int&nbsp;operandOffset,
   double[]&nbsp;result,
   int&nbsp;resultOffset)</code>
<div class="block">Compute power of a double to a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#remainder(double[], int, double[], int, double[], int)">remainder</a></strong>(double[]&nbsp;lhs,
         int&nbsp;lhsOffset,
         double[]&nbsp;rhs,
         int&nbsp;rhsOffset,
         double[]&nbsp;result,
         int&nbsp;resultOffset)</code>
<div class="block">Perform remainder of two derivative structures.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#rootN(double[], int, int, double[], int)">rootN</a></strong>(double[]&nbsp;operand,
     int&nbsp;operandOffset,
     int&nbsp;n,
     double[]&nbsp;result,
     int&nbsp;resultOffset)</code>
<div class="block">Compute n<sup>th</sup> root of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#sin(double[], int, double[], int)">sin</a></strong>(double[]&nbsp;operand,
   int&nbsp;operandOffset,
   double[]&nbsp;result,
   int&nbsp;resultOffset)</code>
<div class="block">Compute sine of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#sinh(double[], int, double[], int)">sinh</a></strong>(double[]&nbsp;operand,
    int&nbsp;operandOffset,
    double[]&nbsp;result,
    int&nbsp;resultOffset)</code>
<div class="block">Compute hyperbolic sine of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#subtract(double[], int, double[], int, double[], int)">subtract</a></strong>(double[]&nbsp;lhs,
        int&nbsp;lhsOffset,
        double[]&nbsp;rhs,
        int&nbsp;rhsOffset,
        double[]&nbsp;result,
        int&nbsp;resultOffset)</code>
<div class="block">Perform subtraction of two derivative structures.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#tan(double[], int, double[], int)">tan</a></strong>(double[]&nbsp;operand,
   int&nbsp;operandOffset,
   double[]&nbsp;result,
   int&nbsp;resultOffset)</code>
<div class="block">Compute tangent of a derivative structure.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#tanh(double[], int, double[], int)">tanh</a></strong>(double[]&nbsp;operand,
    int&nbsp;operandOffset,
    double[]&nbsp;result,
    int&nbsp;resultOffset)</code>
<div class="block">Compute hyperbolic tangent of a derivative structure.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>double</code></td>
<td class="colLast"><code><strong><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#taylor(double[], int, double...)">taylor</a></strong>(double[]&nbsp;ds,
      int&nbsp;dsOffset,
      double...&nbsp;delta)</code>
<div class="block">Evaluate Taylor expansion of a derivative structure.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
<code><a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#clone()" title="class or interface in java.lang">clone</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#equals(java.lang.Object)" title="class or interface in java.lang">equals</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#finalize()" title="class or interface in java.lang">finalize</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#getClass()" title="class or interface in java.lang">getClass</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#hashCode()" title="class or interface in java.lang">hashCode</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#notify()" title="class or interface in java.lang">notify</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#notifyAll()" title="class or interface in java.lang">notifyAll</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang">toString</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#wait()" title="class or interface in java.lang">wait</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#wait(long)" title="class or interface in java.lang">wait</a>, <a href="http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html?is-external=true#wait(long, int)" title="class or interface in java.lang">wait</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method_detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="getCompiler(int, int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getCompiler</h4>
<pre>public static&nbsp;<a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html" title="class in org.apache.commons.math3.analysis.differentiation">DSCompiler</a>&nbsp;getCompiler(int&nbsp;parameters,
                     int&nbsp;order)
                              throws <a href="../../../../../../org/apache/commons/math3/exception/NumberIsTooLargeException.html" title="class in org.apache.commons.math3.exception">NumberIsTooLargeException</a></pre>
<div class="block">Get the compiler for number of free parameters and order.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>parameters</code> - number of free parameters</dd><dd><code>order</code> - derivation order</dd>
<dt><span class="strong">Returns:</span></dt><dd>cached rules set</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../../org/apache/commons/math3/exception/NumberIsTooLargeException.html" title="class in org.apache.commons.math3.exception">NumberIsTooLargeException</a></code> - if order is too large</dd></dl>
</li>
</ul>
<a name="getPartialDerivativeIndex(int...)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getPartialDerivativeIndex</h4>
<pre>public&nbsp;int&nbsp;getPartialDerivativeIndex(int...&nbsp;orders)
                              throws <a href="../../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a>,
                                     <a href="../../../../../../org/apache/commons/math3/exception/NumberIsTooLargeException.html" title="class in org.apache.commons.math3.exception">NumberIsTooLargeException</a></pre>
<div class="block">Get the index of a partial derivative in the array.
 <p>
 If all orders are set to 0, then the 0<sup>th</sup> order derivative
 is returned, which is the value of the function.
 </p>
 <p>The indices of derivatives are between 0 and <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getSize()"><code>getSize()</code></a> - 1.
 Their specific order is fixed for a given compiler, but otherwise not
 publicly specified. There are however some simple cases which have guaranteed
 indices:
 </p>
 <ul>
   <li>the index of 0<sup>th</sup> order derivative is always 0</li>
   <li>if there is only 1 <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getFreeParameters()"><code>free parameter</code></a>, then the
   derivatives are sorted in increasing derivation order (i.e. f at index 0, df/dp
   at index 1, d<sup>2</sup>f/dp<sup>2</sup> at index 2 ...
   d<sup>k</sup>f/dp<sup>k</sup> at index k),</li>
   <li>if the <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getOrder()"><code>derivation order</code></a> is 1, then the derivatives
   are sorted in increasing free parameter order (i.e. f at index 0, df/dx<sub>1</sub>
   at index 1, df/dx<sub>2</sub> at index 2 ... df/dx<sub>k</sub> at index k),</li>
   <li>all other cases are not publicly specified</li>
 </ul>
 <p>
 This method is the inverse of method <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getPartialDerivativeOrders(int)"><code>getPartialDerivativeOrders(int)</code></a>
 </p></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>orders</code> - derivation orders with respect to each parameter</dd>
<dt><span class="strong">Returns:</span></dt><dd>index of the partial derivative</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></code> - if the numbers of parameters does not
 match the instance</dd>
<dd><code><a href="../../../../../../org/apache/commons/math3/exception/NumberIsTooLargeException.html" title="class in org.apache.commons.math3.exception">NumberIsTooLargeException</a></code> - if sum of derivation orders is larger
 than the instance limits</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getPartialDerivativeOrders(int)"><code>getPartialDerivativeOrders(int)</code></a></dd></dl>
</li>
</ul>
<a name="getPartialDerivativeOrders(int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getPartialDerivativeOrders</h4>
<pre>public&nbsp;int[]&nbsp;getPartialDerivativeOrders(int&nbsp;index)</pre>
<div class="block">Get the derivation orders for a specific index in the array.
 <p>
 This method is the inverse of <a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getPartialDerivativeIndex(int...)"><code>getPartialDerivativeIndex(int...)</code></a>.
 </p></div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>index</code> - of the partial derivative</dd>
<dt><span class="strong">Returns:</span></dt><dd>orders derivation orders with respect to each parameter</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html#getPartialDerivativeIndex(int...)"><code>getPartialDerivativeIndex(int...)</code></a></dd></dl>
</li>
</ul>
<a name="getFreeParameters()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFreeParameters</h4>
<pre>public&nbsp;int&nbsp;getFreeParameters()</pre>
<div class="block">Get the number of free parameters.</div>
<dl><dt><span class="strong">Returns:</span></dt><dd>number of free parameters</dd></dl>
</li>
</ul>
<a name="getOrder()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getOrder</h4>
<pre>public&nbsp;int&nbsp;getOrder()</pre>
<div class="block">Get the derivation order.</div>
<dl><dt><span class="strong">Returns:</span></dt><dd>derivation order</dd></dl>
</li>
</ul>
<a name="getSize()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getSize</h4>
<pre>public&nbsp;int&nbsp;getSize()</pre>
<div class="block">Get the array size required for holding partial derivatives data.
 <p>
 This number includes the single 0 order derivative element, which is
 guaranteed to be stored in the first element of the array.
 </p></div>
<dl><dt><span class="strong">Returns:</span></dt><dd>array size required for holding partial derivatives data</dd></dl>
</li>
</ul>
<a name="linearCombination(double, double[], int, double, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>linearCombination</h4>
<pre>public&nbsp;void&nbsp;linearCombination(double&nbsp;a1,
                     double[]&nbsp;c1,
                     int&nbsp;offset1,
                     double&nbsp;a2,
                     double[]&nbsp;c2,
                     int&nbsp;offset2,
                     double[]&nbsp;result,
                     int&nbsp;resultOffset)</pre>
<div class="block">Compute linear combination.
 The derivative structure built will be a1 * ds1 + a2 * ds2</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a1</code> - first scale factor</dd><dd><code>c1</code> - first base (unscaled) component</dd><dd><code>offset1</code> - offset of first operand in its array</dd><dd><code>a2</code> - second scale factor</dd><dd><code>c2</code> - second base (unscaled) component</dd><dd><code>offset2</code> - offset of second operand in its array</dd><dd><code>result</code> - array where result must be stored (it may be
 one of the input arrays)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="linearCombination(double, double[], int, double, double[], int, double, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>linearCombination</h4>
<pre>public&nbsp;void&nbsp;linearCombination(double&nbsp;a1,
                     double[]&nbsp;c1,
                     int&nbsp;offset1,
                     double&nbsp;a2,
                     double[]&nbsp;c2,
                     int&nbsp;offset2,
                     double&nbsp;a3,
                     double[]&nbsp;c3,
                     int&nbsp;offset3,
                     double[]&nbsp;result,
                     int&nbsp;resultOffset)</pre>
<div class="block">Compute linear combination.
 The derivative structure built will be a1 * ds1 + a2 * ds2 + a3 * ds3 + a4 * ds4</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a1</code> - first scale factor</dd><dd><code>c1</code> - first base (unscaled) component</dd><dd><code>offset1</code> - offset of first operand in its array</dd><dd><code>a2</code> - second scale factor</dd><dd><code>c2</code> - second base (unscaled) component</dd><dd><code>offset2</code> - offset of second operand in its array</dd><dd><code>a3</code> - third scale factor</dd><dd><code>c3</code> - third base (unscaled) component</dd><dd><code>offset3</code> - offset of third operand in its array</dd><dd><code>result</code> - array where result must be stored (it may be
 one of the input arrays)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="linearCombination(double, double[], int, double, double[], int, double, double[], int, double, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>linearCombination</h4>
<pre>public&nbsp;void&nbsp;linearCombination(double&nbsp;a1,
                     double[]&nbsp;c1,
                     int&nbsp;offset1,
                     double&nbsp;a2,
                     double[]&nbsp;c2,
                     int&nbsp;offset2,
                     double&nbsp;a3,
                     double[]&nbsp;c3,
                     int&nbsp;offset3,
                     double&nbsp;a4,
                     double[]&nbsp;c4,
                     int&nbsp;offset4,
                     double[]&nbsp;result,
                     int&nbsp;resultOffset)</pre>
<div class="block">Compute linear combination.
 The derivative structure built will be a1 * ds1 + a2 * ds2 + a3 * ds3 + a4 * ds4</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a1</code> - first scale factor</dd><dd><code>c1</code> - first base (unscaled) component</dd><dd><code>offset1</code> - offset of first operand in its array</dd><dd><code>a2</code> - second scale factor</dd><dd><code>c2</code> - second base (unscaled) component</dd><dd><code>offset2</code> - offset of second operand in its array</dd><dd><code>a3</code> - third scale factor</dd><dd><code>c3</code> - third base (unscaled) component</dd><dd><code>offset3</code> - offset of third operand in its array</dd><dd><code>a4</code> - fourth scale factor</dd><dd><code>c4</code> - fourth base (unscaled) component</dd><dd><code>offset4</code> - offset of fourth operand in its array</dd><dd><code>result</code> - array where result must be stored (it may be
 one of the input arrays)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="add(double[], int, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>add</h4>
<pre>public&nbsp;void&nbsp;add(double[]&nbsp;lhs,
       int&nbsp;lhsOffset,
       double[]&nbsp;rhs,
       int&nbsp;rhsOffset,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</pre>
<div class="block">Perform addition of two derivative structures.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>lhs</code> - array holding left hand side of addition</dd><dd><code>lhsOffset</code> - offset of the left hand side in its array</dd><dd><code>rhs</code> - array right hand side of addition</dd><dd><code>rhsOffset</code> - offset of the right hand side in its array</dd><dd><code>result</code> - array where result must be stored (it may be
 one of the input arrays)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="subtract(double[], int, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>subtract</h4>
<pre>public&nbsp;void&nbsp;subtract(double[]&nbsp;lhs,
            int&nbsp;lhsOffset,
            double[]&nbsp;rhs,
            int&nbsp;rhsOffset,
            double[]&nbsp;result,
            int&nbsp;resultOffset)</pre>
<div class="block">Perform subtraction of two derivative structures.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>lhs</code> - array holding left hand side of subtraction</dd><dd><code>lhsOffset</code> - offset of the left hand side in its array</dd><dd><code>rhs</code> - array right hand side of subtraction</dd><dd><code>rhsOffset</code> - offset of the right hand side in its array</dd><dd><code>result</code> - array where result must be stored (it may be
 one of the input arrays)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="multiply(double[], int, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>multiply</h4>
<pre>public&nbsp;void&nbsp;multiply(double[]&nbsp;lhs,
            int&nbsp;lhsOffset,
            double[]&nbsp;rhs,
            int&nbsp;rhsOffset,
            double[]&nbsp;result,
            int&nbsp;resultOffset)</pre>
<div class="block">Perform multiplication of two derivative structures.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>lhs</code> - array holding left hand side of multiplication</dd><dd><code>lhsOffset</code> - offset of the left hand side in its array</dd><dd><code>rhs</code> - array right hand side of multiplication</dd><dd><code>rhsOffset</code> - offset of the right hand side in its array</dd><dd><code>result</code> - array where result must be stored (for
 multiplication the result array <em>cannot</em> be one of
 the input arrays)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="divide(double[], int, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>divide</h4>
<pre>public&nbsp;void&nbsp;divide(double[]&nbsp;lhs,
          int&nbsp;lhsOffset,
          double[]&nbsp;rhs,
          int&nbsp;rhsOffset,
          double[]&nbsp;result,
          int&nbsp;resultOffset)</pre>
<div class="block">Perform division of two derivative structures.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>lhs</code> - array holding left hand side of division</dd><dd><code>lhsOffset</code> - offset of the left hand side in its array</dd><dd><code>rhs</code> - array right hand side of division</dd><dd><code>rhsOffset</code> - offset of the right hand side in its array</dd><dd><code>result</code> - array where result must be stored (for
 division the result array <em>cannot</em> be one of
 the input arrays)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="remainder(double[], int, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>remainder</h4>
<pre>public&nbsp;void&nbsp;remainder(double[]&nbsp;lhs,
             int&nbsp;lhsOffset,
             double[]&nbsp;rhs,
             int&nbsp;rhsOffset,
             double[]&nbsp;result,
             int&nbsp;resultOffset)</pre>
<div class="block">Perform remainder of two derivative structures.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>lhs</code> - array holding left hand side of remainder</dd><dd><code>lhsOffset</code> - offset of the left hand side in its array</dd><dd><code>rhs</code> - array right hand side of remainder</dd><dd><code>rhsOffset</code> - offset of the right hand side in its array</dd><dd><code>result</code> - array where result must be stored (it may be
 one of the input arrays)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="pow(double, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>pow</h4>
<pre>public&nbsp;void&nbsp;pow(double&nbsp;a,
       double[]&nbsp;operand,
       int&nbsp;operandOffset,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</pre>
<div class="block">Compute power of a double to a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - number to exponentiate</dd><dd><code>operand</code> - array holding the power</dd><dd><code>operandOffset</code> - offset of the power in its array</dd><dd><code>result</code> - array where result must be stored (for
 power the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd><dt><span class="strong">Since:</span></dt>
  <dd>3.3</dd></dl>
</li>
</ul>
<a name="pow(double[], int, double, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>pow</h4>
<pre>public&nbsp;void&nbsp;pow(double[]&nbsp;operand,
       int&nbsp;operandOffset,
       double&nbsp;p,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</pre>
<div class="block">Compute power of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>p</code> - power to apply</dd><dd><code>result</code> - array where result must be stored (for
 power the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="pow(double[], int, int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>pow</h4>
<pre>public&nbsp;void&nbsp;pow(double[]&nbsp;operand,
       int&nbsp;operandOffset,
       int&nbsp;n,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</pre>
<div class="block">Compute integer power of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>n</code> - power to apply</dd><dd><code>result</code> - array where result must be stored (for
 power the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="pow(double[], int, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>pow</h4>
<pre>public&nbsp;void&nbsp;pow(double[]&nbsp;x,
       int&nbsp;xOffset,
       double[]&nbsp;y,
       int&nbsp;yOffset,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</pre>
<div class="block">Compute power of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - array holding the base</dd><dd><code>xOffset</code> - offset of the base in its array</dd><dd><code>y</code> - array holding the exponent</dd><dd><code>yOffset</code> - offset of the exponent in its array</dd><dd><code>result</code> - array where result must be stored (for
 power the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="rootN(double[], int, int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>rootN</h4>
<pre>public&nbsp;void&nbsp;rootN(double[]&nbsp;operand,
         int&nbsp;operandOffset,
         int&nbsp;n,
         double[]&nbsp;result,
         int&nbsp;resultOffset)</pre>
<div class="block">Compute n<sup>th</sup> root of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>n</code> - order of the root</dd><dd><code>result</code> - array where result must be stored (for
 n<sup>th</sup> root the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="exp(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>exp</h4>
<pre>public&nbsp;void&nbsp;exp(double[]&nbsp;operand,
       int&nbsp;operandOffset,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</pre>
<div class="block">Compute exponential of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 exponential the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="expm1(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>expm1</h4>
<pre>public&nbsp;void&nbsp;expm1(double[]&nbsp;operand,
         int&nbsp;operandOffset,
         double[]&nbsp;result,
         int&nbsp;resultOffset)</pre>
<div class="block">Compute exp(x) - 1 of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 exponential the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="log(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log</h4>
<pre>public&nbsp;void&nbsp;log(double[]&nbsp;operand,
       int&nbsp;operandOffset,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</pre>
<div class="block">Compute natural logarithm of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 logarithm the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="log1p(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log1p</h4>
<pre>public&nbsp;void&nbsp;log1p(double[]&nbsp;operand,
         int&nbsp;operandOffset,
         double[]&nbsp;result,
         int&nbsp;resultOffset)</pre>
<div class="block">Computes shifted logarithm of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 shifted logarithm the result array <em>cannot</em> be the input array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="log10(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log10</h4>
<pre>public&nbsp;void&nbsp;log10(double[]&nbsp;operand,
         int&nbsp;operandOffset,
         double[]&nbsp;result,
         int&nbsp;resultOffset)</pre>
<div class="block">Computes base 10 logarithm of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 base 10 logarithm the result array <em>cannot</em> be the input array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="cos(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cos</h4>
<pre>public&nbsp;void&nbsp;cos(double[]&nbsp;operand,
       int&nbsp;operandOffset,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</pre>
<div class="block">Compute cosine of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 cosine the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="sin(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sin</h4>
<pre>public&nbsp;void&nbsp;sin(double[]&nbsp;operand,
       int&nbsp;operandOffset,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</pre>
<div class="block">Compute sine of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 sine the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="tan(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>tan</h4>
<pre>public&nbsp;void&nbsp;tan(double[]&nbsp;operand,
       int&nbsp;operandOffset,
       double[]&nbsp;result,
       int&nbsp;resultOffset)</pre>
<div class="block">Compute tangent of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 tangent the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="acos(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>acos</h4>
<pre>public&nbsp;void&nbsp;acos(double[]&nbsp;operand,
        int&nbsp;operandOffset,
        double[]&nbsp;result,
        int&nbsp;resultOffset)</pre>
<div class="block">Compute arc cosine of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 arc cosine the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="asin(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>asin</h4>
<pre>public&nbsp;void&nbsp;asin(double[]&nbsp;operand,
        int&nbsp;operandOffset,
        double[]&nbsp;result,
        int&nbsp;resultOffset)</pre>
<div class="block">Compute arc sine of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 arc sine the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="atan(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>atan</h4>
<pre>public&nbsp;void&nbsp;atan(double[]&nbsp;operand,
        int&nbsp;operandOffset,
        double[]&nbsp;result,
        int&nbsp;resultOffset)</pre>
<div class="block">Compute arc tangent of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 arc tangent the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="atan2(double[], int, double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>atan2</h4>
<pre>public&nbsp;void&nbsp;atan2(double[]&nbsp;y,
         int&nbsp;yOffset,
         double[]&nbsp;x,
         int&nbsp;xOffset,
         double[]&nbsp;result,
         int&nbsp;resultOffset)</pre>
<div class="block">Compute two arguments arc tangent of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>y</code> - array holding the first operand</dd><dd><code>yOffset</code> - offset of the first operand in its array</dd><dd><code>x</code> - array holding the second operand</dd><dd><code>xOffset</code> - offset of the second operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 two arguments arc tangent the result array <em>cannot</em>
 be the input array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="cosh(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cosh</h4>
<pre>public&nbsp;void&nbsp;cosh(double[]&nbsp;operand,
        int&nbsp;operandOffset,
        double[]&nbsp;result,
        int&nbsp;resultOffset)</pre>
<div class="block">Compute hyperbolic cosine of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 hyperbolic cosine the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="sinh(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sinh</h4>
<pre>public&nbsp;void&nbsp;sinh(double[]&nbsp;operand,
        int&nbsp;operandOffset,
        double[]&nbsp;result,
        int&nbsp;resultOffset)</pre>
<div class="block">Compute hyperbolic sine of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 hyperbolic sine the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="tanh(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>tanh</h4>
<pre>public&nbsp;void&nbsp;tanh(double[]&nbsp;operand,
        int&nbsp;operandOffset,
        double[]&nbsp;result,
        int&nbsp;resultOffset)</pre>
<div class="block">Compute hyperbolic tangent of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 hyperbolic tangent the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="acosh(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>acosh</h4>
<pre>public&nbsp;void&nbsp;acosh(double[]&nbsp;operand,
         int&nbsp;operandOffset,
         double[]&nbsp;result,
         int&nbsp;resultOffset)</pre>
<div class="block">Compute inverse hyperbolic cosine of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 inverse hyperbolic cosine the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="asinh(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>asinh</h4>
<pre>public&nbsp;void&nbsp;asinh(double[]&nbsp;operand,
         int&nbsp;operandOffset,
         double[]&nbsp;result,
         int&nbsp;resultOffset)</pre>
<div class="block">Compute inverse hyperbolic sine of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 inverse hyperbolic sine the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="atanh(double[], int, double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>atanh</h4>
<pre>public&nbsp;void&nbsp;atanh(double[]&nbsp;operand,
         int&nbsp;operandOffset,
         double[]&nbsp;result,
         int&nbsp;resultOffset)</pre>
<div class="block">Compute inverse hyperbolic tangent of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>result</code> - array where result must be stored (for
 inverse hyperbolic tangent the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="compose(double[], int, double[], double[], int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>compose</h4>
<pre>public&nbsp;void&nbsp;compose(double[]&nbsp;operand,
           int&nbsp;operandOffset,
           double[]&nbsp;f,
           double[]&nbsp;result,
           int&nbsp;resultOffset)</pre>
<div class="block">Compute composition of a derivative structure by a function.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>operand</code> - array holding the operand</dd><dd><code>operandOffset</code> - offset of the operand in its array</dd><dd><code>f</code> - array of value and derivatives of the function at
 the current point (i.e. at <code>operand[operandOffset]</code>).</dd><dd><code>result</code> - array where result must be stored (for
 composition the result array <em>cannot</em> be the input
 array)</dd><dd><code>resultOffset</code> - offset of the result in its array</dd></dl>
</li>
</ul>
<a name="taylor(double[], int, double...)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>taylor</h4>
<pre>public&nbsp;double&nbsp;taylor(double[]&nbsp;ds,
            int&nbsp;dsOffset,
            double...&nbsp;delta)
              throws <a href="../../../../../../org/apache/commons/math3/exception/MathArithmeticException.html" title="class in org.apache.commons.math3.exception">MathArithmeticException</a></pre>
<div class="block">Evaluate Taylor expansion of a derivative structure.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>ds</code> - array holding the derivative structure</dd><dd><code>dsOffset</code> - offset of the derivative structure in its array</dd><dd><code>delta</code> - parameters offsets (&Delta;x, &Delta;y, ...)</dd>
<dt><span class="strong">Returns:</span></dt><dd>value of the Taylor expansion at x + &Delta;x, y + &Delta;y, ...</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../../org/apache/commons/math3/exception/MathArithmeticException.html" title="class in org.apache.commons.math3.exception">MathArithmeticException</a></code> - if factorials becomes too large</dd></dl>
</li>
</ul>
<a name="checkCompatibility(org.apache.commons.math3.analysis.differentiation.DSCompiler)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>checkCompatibility</h4>
<pre>public&nbsp;void&nbsp;checkCompatibility(<a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DSCompiler.html" title="class in org.apache.commons.math3.analysis.differentiation">DSCompiler</a>&nbsp;compiler)
                        throws <a href="../../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></pre>
<div class="block">Check rules set compatibility.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>compiler</code> - other compiler to check against instance</dd>
<dt><span class="strong">Throws:</span></dt>
<dd><code><a href="../../../../../../org/apache/commons/math3/exception/DimensionMismatchException.html" title="class in org.apache.commons.math3.exception">DimensionMismatchException</a></code> - if number of free parameters or orders are inconsistent</dd></dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar_bottom">
<!--   -->
</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/DSCompiler.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage"><em><script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script></em></div>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/DerivativeStructure.html" title="class in org.apache.commons.math3.analysis.differentiation"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../../../../org/apache/commons/math3/analysis/differentiation/FiniteDifferencesDifferentiator.html" title="class in org.apache.commons.math3.analysis.differentiation"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../../index.html?org/apache/commons/math3/analysis/differentiation/DSCompiler.html" target="_top">Frames</a></li>
<li><a href="DSCompiler.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &#169; 2003&#x2013;2014 <a href="http://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</body>
</html>
